import type { Music } from '@/stores/player'
import request from './request'
import { API_BASE_URL, STATIC_BASE_URL, RESOURCE_BASE_URL } from '@/config'

// 基础音乐数据模板
const defaultMusic: Music = {
  id: '1',
  title: '愿与愁',
  artist: '林俊杰',
  cover: '/src/assets/default-cover.png',
  url: '/src/assets/default-music.mp3',
  lrc: '/src/assets/default-lrc.lrc',
  duration: '231'  // 修改为字符串类型以符合类型定义
}

// 处理资源 URL，确保使用正确的基础地址
const getFullResourceUrl = (url: string | undefined): string => {
  // 如果 url 是 undefined，返回默认封面
  if (!url) {
    return '/src/assets/default-cover.png';
  }
  
  // 如果已经是完整的 URL，直接返回
  if (url.startsWith('http')) {
    return url;
  }

  // 如果是本地资源路径（以 /src 开头）
  if (url.startsWith('/src/')) {
    return url;
  }

  // 其他所有资源（storage 等）都直接拼接资源服务器地址
  return `${RESOURCE_BASE_URL}/${url.startsWith('/') ? url.slice(1) : url}`;
};

/**
 * 获取播放列表
 * @returns Promise<Music[]>
 * 
 * 预期返回数据格式：
 * [
 *   {
 *     id: string,
 *     title: string,
 *     artist: string,
 *     cover: string,
 *     url: string,
 *     lrc: string,
 *     duration: string
 *   },
 *   ...
 * ]
 */
export const getPlaylist = async () => {
  try {
    const response = await request.get('/music/playlist')
    if (response.data.success && response.data.data) {
      return response.data.data.map(processMusicData)
    }
    return [defaultMusic]
  } catch (error) {
    console.error('获取播放列表失败:', error)
    return [defaultMusic]
  }
}

/**
 * 获取热门音乐列表
 * @returns Promise<Music[]>
 * 
 * 请求方式：GET
 * 请求URL：/api/music/hot
 * 
 * 预期返回数据格式：
 * [
 *   {
 *     id: string,          // 音乐ID
 *     title: string,       // 音乐标题
 *     artist: string,      // 艺术家
 *     url: string,         // 音乐文件URL
 *     lrc: string,         // 歌词文件URL
 *     duration: string     // 音乐时长（秒）
 *   },
 *   ...
 * ]
 */
export const getHotMusic = async (): Promise<Music[]> => {
  try {
    const response = await request.get<{ data: Music[], success: boolean }>(`/music/hot`);
    console.log('Hot music response:', response.data);
    
    if (response.data.success && response.data.data) {
      // 处理每首音乐的数据
      return response.data.data.map(processMusicData);
    }
    return [defaultMusic];
  } catch (error) {
    console.error('获取热门音乐失败:', error);
    return [defaultMusic];
  }
}

/**
 * 获取最近播放列表
 */
export const getRecentMusic = async () => {
  try {
    const response = await request.get(`/music/recent-music`)
    if (response.data.success && response.data.data) {
      return response.data.data.map(processMusicData)
    }
    return []
  } catch (error) {
    console.error('获取最近播放列表失败:', error)
    return []
  }
}

/**
 * 添加音乐到播放列表
 * @param musicId 音乐ID
 * @returns Promise<{ success: boolean, message: string }>
 * 
 * 发送数据：
 * { musicId: string }
 * 
 * 预期返回数据：
 * {
 *   success: boolean,
 *   message: string
 * }
 */
export const addToPlaylist = async (musicId: string) => {
  try {
    const response = await request.post('/music/playlist/add', { musicId })
    return response.data
  } catch (error) {
    console.error('添加到播放列表失败:', error)
    return { success: false, message: '添加失败' }
  }
}

/**
 * 从播放列表中移除音乐
 * @param musicId 音乐ID
 * @returns Promise<{ success: boolean, message: string }>
 * 
 * 发送数据：
 * { musicId: string }
 * 
 * 预期返回数据：
 * {
 *   success: boolean,
 *   message: string
 * }
 */
export const removeFromPlaylist = async (musicId: string) => {
  try {
    const response = await request.post('/music/playlist/remove', { musicId })
    return response.data
  } catch (error) {
    console.error('从播放列表移除失败:', error)
    return { success: false, message: '移除失败' }
  }
}

/**
 * 获取音乐详情
 * @param musicId 音乐ID
 * @returns Promise<Music>
 * 
 * 预期返回数据格式：
 * {
 *   id: string,
 *   title: string,
 *   artist: string,
 *   cover: string,
 *   url: string,
 *   lrc: string,
 *   duration: string
 * }
 */
export const getMusicDetail = async (musicId: string) => {
  try {
    const response = await request.get<Music>(`/music/${musicId}`)
    return response.data
  } catch (error) {
    console.error('获取音乐详情失败:', error)
    return defaultMusic
  }
}

/**
 * 更新播放历史
 * @param musicId 音乐ID
 * @returns Promise<{ success: boolean, message: string }>
 * 
 * 发送数据：
 * { musicId: string }
 * 
 * 预期返回数据：
 * {
 *   success: boolean,
 *   message: string
 * }
 */
export const updatePlayHistory = async (musicId: string) => {
  try {
    const response = await request.post('/musichistory/add', { musicId })
    return response.data
  } catch (error) {
    console.error('更新播放历史失败:', error)
    return { success: false, message: '更新失败' }
  }
}

/**
 * 获取单个音乐信息
 * @param musicId 音乐ID
 * @returns Promise<Music>
 * 
 * 请求方式：GET
 * 请求URL：/api/music/:musicId
 * 
 * 预期返回数据格式：
 * {
 *   id: string,          // 音乐ID
 *   title: string,       // 音乐标题
 *   artist: string,      // 艺术家
 *   cover: string,       // 封面图片URL
 *   url: string,         // 音乐文件URL
 *   lrc: string,         // 歌词文件URL
 *   duration: string     // 音乐时长（秒）
 * }
 */
export const getMusicById = async (musicId: string): Promise<Music> => {
  try {
    // 获取基本信息
    const response = await request.get<{ data: Music, success: boolean }>(`/music/${musicId}`)
    if (response.data.success && response.data.data) {
      // 直接使用 processMusicData 处理所有 URL
      return processMusicData(response.data.data)
    }
    return defaultMusic
  } catch (error) {
    console.error('获取音乐信息失败:', error)
    return defaultMusic
  }
}

/**
 * 获取音乐歌词
 * @param musicId 音乐ID
 * @returns Promise<string>
 * 
 * 请求方式：GET
 * 请求URL：/api/music/:musicId/lyric
 * 
 * 预期返回数据格式：
 * {
 *   lyric: string  // LRC格式的歌词文本
 * }
 * 
 * 示例返回数据：
 * {
 *   lyric: "[00:00.000]歌词第一行\n[00:03.456]歌词第二行..."
 * }
 */
export const getMusicLyric = async (musicId: string): Promise<string> => {
  try {
    const response = await request.get<{ data: { lyric: string }, success: boolean }>(`/music/${musicId}/lyric`)
    if (response.data.success && response.data.data) {
      return response.data.data.lyric || ''
    }
    return ''
  } catch (error) {
    console.error('获取歌词失败:', error)
    return ''
  }
}

/**
 * 获取音乐文件的播放地址和授权信息
 * @param musicId 音乐ID
 * @returns Promise<MusicSource>
 * 
 * 请求方式：GET
 * 请求URL：/api/music/:musicId/source
 * 
 * 预期返回数据格式：
 * {
 *   url: string,         // 音乐文件的播放地址
 *   token: string,       // 授权token，用于验证播放权限
 *   expires: number,     // token过期时间戳（毫秒）
 *   bitrate: number,     // 音质码率（比特率）
 *   format: string       // 音频格式(mp3/flac)
 * }
 * 
 */
interface MusicSource {
  url: string
  token: string
  expires: number
  bitrate: number
  format: string
}

export const getMusicSource = async (musicId: string): Promise<MusicSource> => {
  try {
    const response = await request.get<{ 
      data: {
        url: string
        token: string
        expires: number
        bitrate: number
        format: string
      }, 
      success: boolean 
    }>(`/music/${musicId}/source`)
    
    if (response.data.success && response.data.data) {
      const sourceData = response.data.data
      return {
        url: getFullResourceUrl(sourceData.url),
        token: sourceData.token,
        expires: sourceData.expires,
        bitrate: sourceData.bitrate,
        format: sourceData.format
      }
    }
    throw new Error('获取音乐源失败')
  } catch (error) {
    console.error('获取音乐播放信息失败:', error)
    throw error
  }
}

/**
 * 获取音乐文件流
 * @param musicSource 音乐源信息
 * @returns Promise<Blob>
 * 
 * 请求方式：GET
 * 请求URL：从 musicSource.url 获取
 * 请求头：
 * {
 *   Authorization: `Bearer ${musicSource.token}`  // 授权token
 * }
 * 
 * 预返回数据：
 * - 音频文件的二进制数据流
 * - Content-Type 将是 audio/mpeg 或 audio/flac 等音频MIME类型
 * 
 * 错误情况：
 * - 401: token无效或过期
 * - 403: 没有播放权限
 * - 404: 音频文件不存在
 */
export const fetchMusicStream = async (musicSource: MusicSource): Promise<Blob> => {
  try {
    const response = await request.get(musicSource.url, {
      headers: {
        'Authorization': `Bearer ${musicSource.token}`,
      },
      responseType: 'blob'
    })
    return response.data
  } catch (error) {
    console.error('获取音乐文件流失败:', error)
    throw error
  }
}

/**
 * 获取音乐封面
 */
export const getMusicCover = async (musicId: string): Promise<string> => {
  try {
    const response = await request.get<{ data: { url: string }, success: boolean }>(`/music/${musicId}/cover`);
    if (response.data.success && response.data.data) {
      return getFullResourceUrl(response.data.data.url);
    }
    return '/src/assets/default-cover.png';
  } catch (error) {
    console.error('获取音乐封面失败:', error);
    return '/src/assets/default-cover.png';
  }
};

/**
 * 获取音乐库分页数据
 * @param page 页码（从1开始）
 * @param pageSize 每页数量
 * @returns Promise<{ success: boolean, message: string, data?: { total: number, list: Music[] } }>
 * 
 * 请求方式：GET
 * 请求URL：/api/music/library
 * 请求参数：
 * {
 *   page: number,      // 页码
 *   pageSize: number   // 每页数量
 * }
 * 
 * 预期返回数据格式：
 * {
 *   success: boolean,  // 请求是否成功
 *   message: string,   // 提示信息
 *   data?: {
 *     total: number,   // 总记录数
 *     list: Music[]    // 当前页的音乐列表
 *     每个音乐的格式为：
 *     {
 *       id: string,          // 音乐ID
 *       title: string,       // 音乐标题
 *       artist: string,      // 艺术家
 *       cover: string,       // 封面图片URL
 *       url: string,         // 音乐文件URL
 *       lrc: string,         // 歌词文件URL
 *       duration: string     // 音乐时长（秒）
 *     }
 *   }
 * }
 */
export const getMusicLibrary = async (page: number, pageSize: number): Promise<{ 
  success: boolean, 
  message: string, 
  data?: { 
    total: number, 
    list: Music[] 
  } 
}> => {
  try {
    const response = await request.get('/music/library', {
      params: {
        page,
        pageSize
      }
    });
    
    // 为每首歌获取封面
    if (response.data.success && response.data.data?.list) {
      const musicListWithCovers = await Promise.all(
        response.data.data.list.map(async (music: Music) => ({
          ...music,
          cover: await getMusicCover(music.id)
        }))
      );
      return {
        ...response.data,
        data: {
          ...response.data.data,
          list: musicListWithCovers
        }
      };
    }
    
    return response.data;
  } catch (error) {
    console.error('获取音乐库失败:', error);
    return { 
      success: false, 
      message: '获取音乐库失败' 
    };
  }
};

/**
 * 搜索音乐
 * @param keyword 搜索关键词
 * @param limit 限制返回结果数量，默认50
 * @returns Promise<{ success: boolean, message: string, data?: Music[] }>
 * 
 * 预期返回数据格式：
 * {
 *   success: boolean,  // 搜索是否成功
 *   message: string,   // 提示信息
 *   data?: Music[]     // 搜索结果列表
 *   每首歌曲的格式为：
 *   {
 *     id: string,      // 歌曲ID
 *     title: string,   // 歌曲标题
 *     artist: string,  // 艺术家
 *     url: string,     // 音乐文件URL
 *     lrc: string,     // 歌词文件URL
 *     cover: string,   // 歌曲封面URL
 *     duration: string // 音乐时长（秒）
 *   }
 * }
 */
export const searchMusic = async (
  keyword: string,
  limit: number = 50
): Promise<{ success: boolean; message: string; data?: Music[] }> => {
  try {
    const response = await request.get('/music/search', {
      params: {
        keyword,
        limit
      }
    });
    
    if (response.data.success && response.data.data) {
      response.data.data = response.data.data.map(processMusicData);
    }
    return response.data;
  } catch (error) {
    console.error('搜索音乐失败:', error);
    return { success: false, message: '搜索失败' };
  }
};

/**
 * 获取搜索建议
 * @param keyword 搜索关键词
 * @returns Promise<{ success: boolean, message: string, data?: Array<{ title: string, artist: string }> }>
 * 
 * 预期返回数据格式：
 * {
 *   success: boolean,  // 请求是否成功
 *   message: string,   // 提示信息
 *   data?: Array<{     // 搜索建议列表（最多10条）
 *     title: string,   // 歌曲标题
 *     artist: string   // 艺术家
 *   }>
 * }
 * 
 * 说明：
 * 1. 该接口用于实现搜索输入框的实时建议功能
 * 2. 建议使用防抖处理，避免频繁请求
 * 3. 返回结果已按相关度排序
 * 4. 支持歌曲名和歌手名的模糊匹配
 */
export const getMusicSuggestions = async (
  keyword: string
): Promise<{ 
  success: boolean; 
  message: string; 
  data?: Array<{ title: string; artist: string }> 
}> => {
  try {
    const response = await request.get('/music/suggestions', {
      params: { keyword }
    });
    return response.data;
  } catch (error) {
    console.error('获取搜索建议失败:', error);
    return { success: false, message: '获取建议失败' };
  }
};

// 修改获取音乐列表相关的函数，处理音乐文件 URL
const processMusicData = (music: Music): Music => {
  if (!music) return defaultMusic;
  
  return {
    ...music,
    url: getFullResourceUrl(music.url),
    lrc: getFullResourceUrl(music.lrc),
    cover: getFullResourceUrl(music.cover)
  };
};

/**
 * 添加歌曲到最近播放记录
 * @param songId 歌曲ID
 * @returns Promise<{ success: boolean, message: string }>
 * 
 * 请求方式：POST
 * 请求URL：/api/music/{songId}/play
 * 请求参数：
 * - 路径参数：
 *   songId: string     // 歌曲ID
 * - 请求体：无
 * - 请求头：
 *   需要携带用户登录的 session/token
 * 
 * 预期返回数据格式：
 * {
 *   success: boolean,  // 请求是否成功
 *   message: string    // 提示信息
 * }
 * 
 * 可能的返回状态：
 * - 200: 添加成功
 * - 401: 未登录
 * - 500: 服务器错误
 */
export const addToRecentPlay = async (songId: string): Promise<{ 
  success: boolean, 
  message: string 
}> => {
  try {
    const response = await request.post(`/music/${songId}/play`)
    return response.data
  } catch (error: any) {
    // 处理特定的错误状态
    if (error.response?.status === 401) {
      return {
        success: false,
        message: '请先登录'
      }
    }
    console.error('添加到最近播放失败:', error)
    return {
      success: false,
      message: '添加到最近播放失败'
    }
  }
}

/**
 * 清空播放列表
 * @returns Promise<{ success: boolean, message: string }>
 * 
 * 请求方式：DELETE
 * 请求URL：/api/music/playlist/clear
 * 
 * 预期返回数据格式：
 * {
 *   success: boolean,  // 请求是否成功
 *   message: string    // 提示信息
 * }
 * 
 * 可能的返回状态：
 * - 200: 清空成功
 * - 401: 未登录
 * - 500: 服务器错误
 */
export const clearPlaylist = async (): Promise<{ 
  success: boolean, 
  message: string 
}> => {
  try {
    const response = await request.delete('/music/playlist/clear')
    return response.data
  } catch (error: any) {
    // 处理特定的错误状态
    if (error.response?.status === 401) {
      return {
        success: false,
        message: '请先登录'
      }
    }
    console.error('清空播放列表失败:', error)
    return {
      success: false,
      message: '清空播放列表失败'
    }
  }
}

/**
 * 增加歌曲播放量
 * @param id 音乐ID
 * @returns Promise<{ success: boolean; message?: string }>
 */
export const increasePlayCount = async (id: string) => {
  try {
    const response = await request.post(`/music/${id}/play-count`)
    return {
      success: true,
      message: response.data.message
    }
  } catch (error) {
    console.error('增加播放量失败:', error)
    return {
      success: false,
      message: '增加播放量失败'
    }
  }
}